package org.example.synchronizedSty;

/*
* 死锁：线程1等待线程2互斥持有的资源，而线程2也在等待线程1互斥持有的资源，两个线程都无法继续执行
* 解决方法：
* 1. 避免嵌套锁
* 2. 避免持有多个锁
* 3. 避免锁顺序不一致
* 4. 避免锁持有时间过长
* 5. 使用锁的超时机制
* 6. 使用锁的tryLock方法
* 7. 使用锁的公平策略
* 8. 使用锁的读写分离
* 9. 使用锁的降级
* 10. 使用锁的升级
 * */
/*
* 活锁：线程持续重试一个总是失败的操作，导致无法继续执行
* 解决方法：
* 1. 使用随机等待时间
* 2. 使用指数退避
* 3. 使用随机退避
* 4. 使用随机重试
* 5. 使用随机延迟*
 * */
/*
* 饿死：线程一直被调度器延迟访问其赖以执行的资源，也许是调度器先于低优先级的线程而执行高优先级的线程，
*       同时总是会有一个高优先级的线程可以执行，饿死也叫做无限延迟
* 解决方法：
* 1. 使用优先级继承
* 2. 使用优先级提升
* 3. 使用优先级反转
 * */
public class deadlock {
    private Object lock1=new Object();
    private Object lock2=new Object();
    public void myMethod1(){
        synchronized(lock1){
            synchronized(lock2){
                System.out.println("myMethodl invoked");
            }
        }
    }
    public void myMethod2(){
        synchronized(lock2){
            synchronized(lock1){
                System.out.println("myMethod2 invoked");
            }
        }
    }
    public static void main(String[]args){
        deadlock deadlock =new deadlock();
        Runnable runnable1 =()->{
            while(true){
                deadlock.myMethod1();
                try {
                    Thread.sleep(100);
                }catch(InterruptedException ex){
                }
            }
        };
        Thread thread1 =new Thread(runnable1,"myThread1");
        Runnable runnable2 =()->{
            while(true){
                deadlock.myMethod2();
                try {
                    Thread.sleep(250);
                }catch(InterruptedException ex){
                }
            }
        };
        Thread thread2=new Thread(runnable2,"myThread2");
        thread1.start();
        thread2.start();
    }

}
